src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/DataGrid/SampleData.cs-12-13 (1)

12-13: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Deterministic claim is broken by DateTime.Today

Line 29 makes generated data drift day-to-day, so the “reproducible” promise in Line 12 is not true across dates.

Suggested fix

 public static List<Product> Generate(int count, int seed = 42)
 {
     var rng = new Random(seed);
+    var baseDate = new DateTime(2024, 1, 1);
     var categories = Enum.GetValues<Category>();
     var list = new List<Product>(count);
@@
-                ReleaseDate = DateTime.Today.AddDays(-rng.Next(0, 2000)),
+                ReleaseDate = baseDate.AddDays(-rng.Next(0, 2000)),

Also applies to: 29-29

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/DataGrid/SampleData.cs`
around lines 12 - 13, The Generate method in the SampleData class claims to be
deterministic and reproducible in its summary, but it uses DateTime.Today on
line 29 which changes daily and breaks the deterministic guarantee. Replace the
DateTime.Today usage with a fixed, seed-based date value that remains consistent
regardless of when the method is called. This ensures the data generation is
truly reproducible and matches the claim in the method's XML summary comment.

src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/DataGrid/BitDataGridDemo.razor.samples.cs-223-225 (1)

223-225: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Example 16 sample is missing the OnCellDoubleClick handler

Line 224 wires OnCellDoubleClick, but the paired C# snippet (Lines 230-231) does not define it.

Suggested fix

 void OnCellClick(BitDataGridCellEventArgs<Product> e) { /* e.Item, e.ColumnTitle, e.Value */ }
+void OnCellDoubleClick(BitDataGridCellEventArgs<Product> e) { /* ... */ }
 void OnCellContextMenu(BitDataGridCellEventArgs<Product> e) { /* e.Mouse.ClientX / e.Mouse.ClientY */ }

Also applies to: 230-231

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/DataGrid/BitDataGridDemo.razor.samples.cs`
around lines 223 - 225, The Razor component in Example 16 declares an
OnCellDoubleClick event handler in the markup, but the corresponding C# method
is missing from the code-behind. Add the OnCellDoubleClick handler method in the
C# section of BitDataGridDemo.razor.samples.cs following the same pattern and
signature as the existing OnCellClick and OnCellContextMenu handler methods.
Ensure the method is defined in the appropriate location within the Example 16
sample code block so it matches the event binding in the markup.

src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/DataGrid/BitDataGridDemo.razor.cs-148-163 (1)

148-163: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Honor all sort descriptors in the read handlers.

Both handlers only apply request.Sorts.FirstOrDefault(), so additional sort descriptors are ignored and multi-sort requests produce incorrect ordering.

Suggested fix

-        var sort = request.Sorts.FirstOrDefault();
-        if (sort is not null)
+        IOrderedEnumerable<Product>? ordered = null;
+        foreach (var sort in request.Sorts)
         {
             Func<Product, object> key = sort.ColumnId switch
             {
                 nameof(Product.Name) => p => p.Name,
                 nameof(Product.Category) => p => p.Category,
                 nameof(Product.Supplier) => p => p.Supplier,
                 nameof(Product.Price) => p => p.Price,
                 nameof(Product.Stock) => p => p.Stock,
+                nameof(Product.Rating) => p => p.Rating,
                 _ => p => p.Id
             };
-            query = sort.Direction == BitDataGridSortDirection.Descending
-                ? query.OrderByDescending(key)
-                : query.OrderBy(key);
+            ordered = ordered is null
+                ? (sort.Direction == BitDataGridSortDirection.Descending
+                    ? query.OrderByDescending(key)
+                    : query.OrderBy(key))
+                : (sort.Direction == BitDataGridSortDirection.Descending
+                    ? ordered.ThenByDescending(key)
+                    : ordered.ThenBy(key));
         }
+        if (ordered is not null) query = ordered;

Also applies to: 182-198

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/DataGrid/BitDataGridDemo.razor.cs`
around lines 148 - 163, The current implementation only processes the first sort
descriptor using request.Sorts.FirstOrDefault(), which causes multi-sort
requests to be ignored. Replace the if statement that checks for a single sort
with a loop that iterates through all items in request.Sorts collection. For
each sort descriptor, apply the appropriate sort operation (OrderBy or
OrderByDescending based on sort.Direction) to the query in sequence. The switch
statement logic for mapping sort.ColumnId to the appropriate property key should
remain the same, but needs to be executed for every sort descriptor in the
collection rather than just the first one.

src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/DataGrid/BitDataGridDemo.razor.cs-203-205 (1)

203-205: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Handle empty final batches in infinite-scroll status text.

When no rows are returned, the current log renders an inverted range (start > end), which is misleading.

Suggested fix

-        var end = request.Skip + batch.Count;
-        infiniteLog = $"Batch #{infiniteRequests} → loaded rows {request.Skip + 1}–{end} ({batch.Count} rows)";
+        if (batch.Count == 0)
+        {
+            infiniteLog = $"Batch #{infiniteRequests} → no more rows to load.";
+        }
+        else
+        {
+            var end = request.Skip + batch.Count;
+            infiniteLog = $"Batch #{infiniteRequests} → loaded rows {request.Skip + 1}–{end} ({batch.Count} rows)";
+        }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/DataGrid/BitDataGridDemo.razor.cs`
around lines 203 - 205, The infiniteLog message construction does not handle the
case when batch.Count is zero (empty final batch), resulting in a misleading
inverted range display (e.g., "loaded rows 101–100"). Add a conditional check
before assigning to infiniteLog to detect when batch.Count equals zero and
either skip the log update entirely or provide an alternative status message
that clearly indicates no additional rows were loaded, while preserving the
current log message logic for non-empty batches.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGridColumn.cs-126-130 (1)

126-130: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Clear stale accessor when Field is removed.

Line 128 sets Accessor only when HasField is true; if Field changes from populated to null/empty, the previous accessor remains active.

Proposed fix

     protected override void OnParametersSet()
     {
         if (HasField)
             Accessor = BitDataGridPropertyAccessor<TItem>.For(Field!);
+        else
+            Accessor = null;
     }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGridColumn.cs`
around lines 126 - 130, In the OnParametersSet method of the BitDataGridColumn
class, the Accessor is only set when HasField is true, but when Field is cleared
or removed (HasField becomes false), the previous accessor remains active and is
never cleared. Add an else clause after the if (HasField) condition that sets
Accessor to null when HasField is false, ensuring stale accessors are properly
cleaned up when the Field parameter changes from a value to null or empty.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.scss-8-8 (1)

8-8: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Fix Stylelint value-keyword-case violation in font stack.

Line 8 currently triggers lint errors; quote named font families so lint passes without changing fallback behavior.

Proposed fix

-    --bit-dtg-font: 14px/1.4 system-ui, -apple-system, Segoe UI, Roboto, sans-serif;
+    --bit-dtg-font: 14px/1.4 system-ui, -apple-system, "Segoe UI", "Roboto", sans-serif;

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.scss` at
line 8, The font stack in the --bit-dtg-font custom property on line 8 of
BitDataGrid.scss triggers a stylelint value-keyword-case violation because font
family names are not properly quoted. Quote all font family names in the font
stack (system-ui, -apple-system, Segoe UI, Roboto, and sans-serif) individually
in the declaration to ensure stylelint compliance while maintaining the same
fallback behavior.

Source: Linters/SAST tools

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Models/BitDataGridReadRequest.cs-20-20 (1)

20-20: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

CancellationToken is never populated by the grid.

The CancellationToken property exists but is never set when constructing BitDataGridReadRequest instances in LoadNextBatchAsync or LoadServerDataAsync. Consumers will always receive CancellationToken.None, making this property ineffective for request cancellation.

Consider wiring a CancellationTokenSource that cancels on component disposal or when a new request supersedes an in-flight one.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Models/BitDataGridReadRequest.cs`
at line 20, The CancellationToken property in BitDataGridReadRequest is declared
but never initialized when instances are created in LoadNextBatchAsync and
LoadServerDataAsync methods. To fix this, create a CancellationTokenSource field
in the grid component and pass its Token property to the CancellationToken
property when constructing each BitDataGridReadRequest instance. Additionally,
dispose the previous CancellationTokenSource and create a new one for each
request to handle superseding in-flight requests, and ensure the
CancellationTokenSource is disposed when the component is disposed to properly
clean up resources.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor.cs-557-566 (1)

557-566: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Dead code: || true makes !MultiSort ineffective.

Line 557's condition (!MultiSort || true) always evaluates to true, making the !MultiSort check dead code. Additionally, line 560 redundantly re-checks !additive.

This appears to be leftover from refactoring. Simplify to the intended logic:

🧹 Proposed fix

-        if (!additive && (!MultiSort || true))
-        {
-            // Single sort: clear others unless additive
-            if (!additive)
-            {
-                var keep = existing;
-                _sorts.Clear();
-                if (keep is not null) _sorts.Add(keep);
-            }
-        }
+        if (!additive)
+        {
+            // Single sort: clear others
+            var keep = existing;
+            _sorts.Clear();
+            if (keep is not null) _sorts.Add(keep);
+        }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor.cs`
around lines 557 - 566, The condition in the BitDataGrid.razor.cs sort handling
logic contains `|| true` on line 557, which makes the `!MultiSort` check
ineffective and represents dead code. Additionally, the inner if statement on
line 560 redundantly re-checks the `!additive` condition that was already
evaluated in the outer if. To fix this, remove the `|| true` portion from the
outer condition so it properly checks both `!additive && !MultiSort`, and remove
the redundant inner `if (!additive)` block, moving its contents (the sort
clearing logic) to directly execute within the outer if block since the
condition already guarantees additive is false.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor.cs-1087-1101 (1)

1087-1101: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

CSV export may throw if GetFormattedValue returns null.

GetFormattedValue(item) at line 1094 could potentially return null, and passing null to Escape() would cause a NullReferenceException on the .Contains() call.

🐛 Proposed fix

     public string ToCsv()
     {
         var cols = VisibleColumns.Where(c => c.HasField).ToList();
         var sb = new System.Text.StringBuilder();
         sb.AppendLine(string.Join(",", cols.Select(c => Escape(c.DisplayTitle))));
         var rows = IsServerMode ? _pageItems : _view;
         foreach (var item in rows)
-            sb.AppendLine(string.Join(",", cols.Select(c => Escape(c.GetFormattedValue(item)))));
+            sb.AppendLine(string.Join(",", cols.Select(c => Escape(c.GetFormattedValue(item) ?? ""))));
         return sb.ToString();

         static string Escape(string v)
-            => v.Contains(',') || v.Contains('"') || v.Contains('\n')
+            => v is null ? "" : v.Contains(',') || v.Contains('"') || v.Contains('\n')
                 ? "\"" + v.Replace("\"", "\"\"") + "\""
                 : v;
     }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor.cs`
around lines 1087 - 1101, The ToCsv() method passes the return value of
GetFormattedValue(item) directly to the Escape() helper function, but
GetFormattedValue can return null, causing a NullReferenceException when Escape
tries to call .Contains() on the null value. Fix this by adding null handling to
the Escape() method—either at the start of the method by converting null to an
empty string using the null coalescing operator, or by using the null coalescing
operator when calling GetFormattedValue(item) in the Select expression to ensure
Escape always receives a non-null string value.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Infrastructure/BitDataGridPropertyAccessor.cs-74-84 (1)

74-84: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Reject empty/whitespace paths up front

For("")/For(" ") currently builds an accessor for the entire item object, which silently masks misconfigured columns and leads to incorrect sort/filter behavior.

Suggested patch

 public static BitDataGridPropertyAccessor<TItem> For(string path)
-    => Cache.GetOrAdd(path, Build);
+{
+    if (string.IsNullOrWhiteSpace(path))
+        throw new ArgumentException("Property path cannot be null, empty, or whitespace.", nameof(path));
+
+    return Cache.GetOrAdd(path, Build);
+}

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Infrastructure/BitDataGridPropertyAccessor.cs`
around lines 74 - 84, The For method does not validate the input path parameter
before caching and building the accessor. Add validation at the start of the For
method to check if the path is null, empty, or contains only whitespace
characters. If the path is invalid, throw an appropriate exception to reject the
invalid input and prevent the silent masking of misconfigured columns that
currently occurs when an empty or whitespace-only path is passed to For.

src/BlazorUI/Bit.BlazorUI.Extras/Components/QuickGrid/BitQuickGrid.razor-107-107 (1)

107-107: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Fix virtualized placeholder aria-rowindex offset.

Line 107 should account for the header row. Non-virtual rows start at index 2 (Line 54), but placeholders currently start at 1, which misreports row positions to assistive tech.

Suggested fix

-        <tr aria-rowindex="@(placeholderContext.Index + 1)">
+        <tr aria-rowindex="@(placeholderContext.Index + 2)">

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/QuickGrid/BitQuickGrid.razor` at
line 107, The aria-rowindex attribute in the virtualized placeholder row
template is not accounting for the header row offset. The placeholder row on
line 107 uses placeholderContext.Index + 1, but it should use
placeholderContext.Index + 2 to match the offset used in non-virtual rows (which
start at index 2 to account for the header). Update the aria-rowindex expression
to add 2 instead of 1 to ensure correct row position reporting to assistive
technologies.

src/BlazorUI/Bit.BlazorUI.Extras/Styles/extra-components.scss-4-5 (1)

4-5: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Remove .scss extensions in new imports to satisfy Stylelint.

Lines 4-5 currently violate scss/load-partial-extension.

Suggested fix

-@import "../Components/QuickGrid/BitQuickGrid.scss";
-@import "../Components/QuickGrid/Pagination/BitQuickGridPaginator.scss";
+@import "../Components/QuickGrid/BitQuickGrid";
+@import "../Components/QuickGrid/Pagination/BitQuickGridPaginator";

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Styles/extra-components.scss` around lines 4
- 5, Remove the `.scss` file extensions from the `@import` statements on lines
4-5. Change the imports for BitQuickGrid.scss and BitQuickGridPaginator.scss to
remove the `.scss` extension so they reference just the partial names without
the extension, which satisfies the scss/load-partial-extension Stylelint rule
that disallows explicit file extensions in SCSS imports.

Source: Linters/SAST tools

src/BlazorUI/Bit.BlazorUI.Extras/Components/QuickGrid/BitQuickGrid.razor.cs-129-134 (1)

129-134: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Typo in XML documentation.

Line 131 has a typo: "A callback that supplies data for the rid" should be "A callback that supplies data for the grid".

📝 Proposed fix

     /// <summary>
-    /// A callback that supplies data for the rid.
+    /// A callback that supplies data for the grid.
     ///
     /// You should supply either <see cref="Items"/> or <see cref="ItemsProvider"/>, but not both.
     /// </summary>

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/QuickGrid/BitQuickGrid.razor.cs`
around lines 129 - 134, Fix the typo in the XML documentation comment for the
ItemsProvider parameter where it currently states "A callback that supplies data
for the rid" should be corrected to "A callback that supplies data for the
grid". Locate the summary element in the XML comment block preceding the
ItemsProvider property declaration and change the word "rid" to "grid" to
accurately describe what the callback supplies data for.

src/BlazorUI/Bit.BlazorUI.Extras/Components/QuickGrid/BitQuickGrid.razor.cs-346-353 (1)

346-353: ⚠️ Potential issue | 🟡 Minor

Await SetTotalItemCountAsync calls to ensure exceptions are not swallowed.

Pagination?.SetTotalItemCountAsync(result.TotalItemCount) is not awaited. The method can perform asynchronous work through TotalItemCountChangedSubscribable.InvokeCallbacksAsync() or SetCurrentPageIndexAsync(), either of which may trigger component updates and can throw exceptions. Without awaiting, any exceptions from these async operations will be silently swallowed. The same pattern appears at line 392.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/QuickGrid/BitQuickGrid.razor.cs`
around lines 346 - 353, The SetTotalItemCountAsync method call on the Pagination
object is not being awaited, which means any exceptions thrown by async
operations within it (such as
TotalItemCountChangedSubscribable.InvokeCallbacksAsync or
SetCurrentPageIndexAsync) will be silently swallowed. Add the await keyword
before the Pagination?.SetTotalItemCountAsync(result.TotalItemCount) call to
properly handle exceptions. Apply the same fix to both occurrences of this
pattern in the BitQuickGrid.razor.cs file.

src/BlazorUI/Bit.BlazorUI.Extras/Components/QuickGrid/BitQuickGrid.scss-15-16 (1)

15-16: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Fix transition declaration so the delay is applied.

At Line 15, transition-delay is overridden by the shorthand on Line 16, so the delay never takes effect.

💡 Suggested fix

-        transition-delay: 25ms;
-        transition: opacity linear 100ms;
+        transition: opacity linear 100ms 25ms;

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/QuickGrid/BitQuickGrid.scss`
around lines 15 - 16, The shorthand transition property on line 16 overrides the
transition-delay specified on line 15, causing the delay to be lost. Combine
both properties into a single shorthand transition declaration that includes the
delay value as the fourth parameter: change the two separate lines to a single
transition property that specifies opacity, linear, the 100ms duration, and the
25ms delay in the correct order.

Source: Linters/SAST tools

src/BlazorUI/Bit.BlazorUI.Extras/Components/QuickGrid/Columns/BitQuickGridSort.cs-31-35 (1)

31-35: ⚠️ Potential issue | 🟡 Minor

Update XML documentation generic type references.

The class BitQuickGridSort<TGridItem> has mismatched generic parameters in four methods' XML documentation. All instances use <see cref="BitQuickGridSort{T}"/> instead of <see cref="BitQuickGridSort{TGridItem}"/>, which will produce unresolved-cref warnings.

Apply the following changes to all four methods:

Required fixes

• ByAscending method (lines 31, 35): Replace BitQuickGridSort{T} with BitQuickGridSort{TGridItem} in both the summary and returns documentation.
• ByDescending method (lines 41, 45): Replace BitQuickGridSort{T} with BitQuickGridSort{TGridItem} in both the summary and returns documentation.
• ThenAscending method (lines 51, 55): Replace BitQuickGridSort{T} with BitQuickGridSort{TGridItem} in both the summary and returns documentation.
• ThenDescending method (lines 68, 72): Replace BitQuickGridSort{T} with BitQuickGridSort{TGridItem} in both the summary and returns documentation.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/QuickGrid/Columns/BitQuickGridSort.cs`
around lines 31 - 35, In the BitQuickGridSort class, update the XML
documentation for the four sorting methods (ByAscending, ByDescending,
ThenAscending, and ThenDescending) to use the correct generic type parameter.
Replace all instances of `BitQuickGridSort{T}` with
`BitQuickGridSort{TGridItem}` in the see cref tags within both the summary and
returns elements of each method's documentation to match the actual class
generic parameter name and resolve cref warnings.

src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/QuickGrid/BitQuickGridDemo.razor-20-20 (1)

20-20: ⚠️ Potential issue | 🟡 Minor

Add Rel attribute to protect the target="_blank" link.

BitLink does not automatically apply rel="noopener noreferrer" for external links. Add Rel="BitLinkRels.NoOpener | BitLinkRels.NoReferrer" to prevent opener access:

<BitLink Href="https://www.nuget.org/packages/Bit.BlazorUI.Extras" 
         Target="_blank"
         Rel="BitLinkRels.NoOpener | BitLinkRels.NoReferrer">

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/QuickGrid/BitQuickGridDemo.razor`
at line 20, The BitLink component with Target="_blank" is missing the Rel
attribute which is needed for security protection against opener access. Add the
Rel attribute to the BitLink component (around line 20) with the value
"BitLinkRels.NoOpener | BitLinkRels.NoReferrer" to properly secure the external
link. This will prevent the opened page from accessing the window.opener object.

src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/QuickGrid/BitQuickGridDemo.razor-101-101 (1)

101-101: ⚠️ Potential issue | 🟡 Minor

Use distinct @ref variables for the two product grids.

At lines 101 and 116, both BitQuickGrid instances share the same component reference @ref="productsDataGrid", causing the second grid to overwrite the first. The ODataSampleNameFilter property setter (in code-behind) refreshes only the last rendered grid instance, breaking the intended refresh behavior for the virtualized grid.

Suggested fix

-<BitQuickGrid `@ref`="productsDataGrid" ItemsProvider="`@productsItemsProvider`" ItemKey="(p => p.Id)" TGridItem="ProductDto" Virtualize>
+<BitQuickGrid `@ref`="odataProductsDataGrid" ItemsProvider="`@productsItemsProvider`" ItemKey="(p => p.Id)" TGridItem="ProductDto" Virtualize>

-<BitQuickGrid `@ref`="productsDataGrid" ItemsProvider="`@productsItemsProvider`" ItemKey="(p => p.Id)" TGridItem="ProductDto" Pagination="pagination3">
+<BitQuickGrid `@ref`="loadingTemplateProductsDataGrid" ItemsProvider="`@productsItemsProvider`" ItemKey="(p => p.Id)" TGridItem="ProductDto" Pagination="pagination3">

Also declare these fields in BitQuickGridDemo.razor.cs and update the ODataSampleNameFilter setter to refresh the correct grid reference.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/QuickGrid/BitQuickGridDemo.razor`
at line 101, The two BitQuickGrid instances in the template are sharing the same
`@ref` variable "productsDataGrid", causing the second grid to overwrite the first
reference. Create distinct `@ref` variables for each BitQuickGrid component (one
for the virtualized grid and one for the other grid), then declare corresponding
fields in the BitQuickGridDemo.razor.cs code-behind file for each of these new
references. Finally, update the ODataSampleNameFilter property setter to refresh
the correct grid instance based on which grid should be updated when the filter
changes.

src/BlazorUI/Bit.BlazorUI.Extras/Components/QuickGrid/BitQuickGrid.razor.cs (1)

447-462: 💤 Low value

Consider avoiding repeated List<string> allocations.

GetRowClass and GetRowStyle (lines 447-479) allocate a new List<string> on every row render. For grids with many rows, this could add GC pressure. Consider using a StringBuilder or direct string concatenation since you're only combining at most two values.

♻️ Possible simplification

     private string? GetRowClass(TGridItem item)
     {
-        var classes = new List<string>();
-
-        if (RowClass is not null)
-        {
-            classes.Add(RowClass);
-        }
-
-        if (RowClassSelector is not null)
-        {
-            classes.Add(RowClassSelector(item));
-        }
-
-        return classes.Any() ? string.Join(' ', classes) : null;
+        var baseClass = RowClass;
+        var selectorClass = RowClassSelector?.Invoke(item);
+        
+        return (baseClass, selectorClass) switch
+        {
+            (not null, not null) => $"{baseClass} {selectorClass}",
+            (not null, null) => baseClass,
+            (null, not null) => selectorClass,
+            _ => null
+        };
     }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/QuickGrid/BitQuickGrid.razor.cs`
around lines 447 - 462, The GetRowClass and GetRowStyle methods allocate a new
List<string> on every row render, which creates unnecessary garbage collection
pressure when rendering large grids. Replace the List<string> allocation and
join pattern with direct string concatenation in both methods. Since you're
combining at most two values in each method (RowClass and RowClassSelector for
GetRowClass, and similarly for GetRowStyle), you can build the result string
directly by checking the conditions and concatenating the values with a space
separator only when both values exist, avoiding the List allocation entirely.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.scss (1)

218-227: 🧹 Nitpick | 🔵 Trivial | ⚡ Quick win

Respect reduced-motion user preference for spinner/shimmer animations.

The grid always animates loading indicators. Add a prefers-reduced-motion fallback so motion-sensitive users are not forced into continuous animation.

Suggested fix

 `@keyframes` bit-dtg-spin { to { transform: rotate(360deg); } }
@@
 `@keyframes` bit-dtg-shimmer { 0% { background-position: 100% 0; } 100% { background-position: 0 0; } }
+
+@media (prefers-reduced-motion: reduce) {
+    .bit-dtg-spinner,
+    .bit-dtg-skeleton {
+        animation: none;
+    }
+}

Also applies to: 231-243

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.scss` around
lines 218 - 227, The BitDataGrid spinner and shimmer animations do not respect
user accessibility preferences for reduced motion. Wrap the animation properties
in the `.bit-dtg-spinner` rule and the related animation rules (lines 231-243)
in a `@media (prefers-reduced-motion: no-preference)` query so animations only
play for users who have not requested reduced motion. For users with
`prefers-reduced-motion: reduce`, provide fallback styles that disable the
animation property, ensuring the spinner/shimmer elements remain visible but
static.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor (2)

265-270: 🧹 Nitpick | 🔵 Trivial | ⚡ Quick win

Add @key to virtualized row for identity consistency.

The infinite (line 246) and paged (line 275) render paths use @key="item", but the virtualized path does not. Adding @key ensures consistent item identity tracking across all rendering modes, which helps Blazor optimize DOM updates when items are reordered or modified.

♻️ Suggested fix

 else if (UseVirtualization)
 {
     <Virtualize Items="VirtualRows" ItemSize="RowHeight" Context="item" TItem="TItem">
-        <BitDataGridRow TItem="TItem" Grid="this" Item="item" />
+        <BitDataGridRow TItem="TItem" Grid="this" Item="item" `@key`="item" />
     </Virtualize>
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor`
around lines 265 - 270, The virtualized rendering path in the UseVirtualization
condition is missing the `@key` directive on the BitDataGridRow component, while
the infinite and paged rendering paths both include `@key`="item". Add `@key`="item"
to the BitDataGridRow component inside the Virtualize block to ensure consistent
item identity tracking across all rendering modes and allow Blazor to properly
optimize DOM updates when items are reordered or modified.

---

336-338: 🧹 Nitpick | 🔵 Trivial | ⚡ Quick win

Cache VirtualRows to avoid repeated list allocation.

VirtualRows calls ToList() on every access when _view is not an ICollection<TItem>. Since Virtualize may access Items multiple times during rendering, this creates unnecessary allocations. Consider caching the list when the view changes instead of computing it on each access.

♻️ Suggested approach

Add a cached field that is populated when _view changes (e.g., in ProcessClientData or RefreshAsync):

// In code-behind
private ICollection<TItem>? _cachedVirtualRows;

// Update when _view changes
_cachedVirtualRows = _view as ICollection<TItem> ?? _view.ToList();

Then in the Razor:

-private ICollection<TItem> VirtualRows => _view as ICollection<TItem> ?? _view.ToList();
+private ICollection<TItem> VirtualRows => _cachedVirtualRows ?? [];

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor`
around lines 336 - 338, The VirtualRows property currently calls ToList() on
every access when _view is not an ICollection<TItem>, causing repeated
allocations during rendering cycles. Add a private cached field to store the
computed virtual rows collection, then populate this cache whenever _view
changes (such as in ProcessClientData or RefreshAsync methods). Update the
VirtualRows property to return the cached field instead of computing the
collection on each access, ensuring the cache remains synchronized whenever the
underlying _view is modified.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor.cs (1)

220-222: 🧹 Nitpick | 🔵 Trivial | 💤 Low value

Consider caching VisibleColumns to avoid repeated allocations.

VisibleColumns creates a new list on every property access via .ToList(). This property is accessed frequently during rendering (in BitDataGridRow, keyboard navigation, column spanning, etc.). Consider caching the result and invalidating when columns change.

♻️ Suggested caching pattern

+ private IReadOnlyList<BitDataGridColumn<TItem>>? _visibleColumnsCache;
+ private int _columnsVersion;

- internal IReadOnlyList<BitDataGridColumn<TItem>> VisibleColumns => _columns.Where(c => c.Visible).ToList();
+ internal IReadOnlyList<BitDataGridColumn<TItem>> VisibleColumns => _visibleColumnsCache ??= _columns.Where(c => c.Visible).ToList();

  internal void AddColumn(BitDataGridColumn<TItem> column)
  {
      if (_columns.Contains(column)) return;
      _columns.Add(column);
      _columnsById[column.Id] = column;
+     _visibleColumnsCache = null;
      InvokeAsync(StateHasChanged);
  }

  internal void RemoveColumn(BitDataGridColumn<TItem> column)
  {
      if (_columns.Remove(column))
      {
          _columnsById.Remove(column.Id);
+         _visibleColumnsCache = null;
          InvokeAsync(StateHasChanged);
      }
  }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor.cs`
around lines 220 - 222, The VisibleColumns property in the BitDataGrid class
creates a new list on every access via .ToList(), causing unnecessary
allocations since this property is accessed frequently during rendering.
Implement caching by creating a private backing field to store the visible
columns list, update this cached list whenever the underlying _columns
collection changes (add invalidation logic in methods that modify _columns such
as column add/remove operations), and modify the VisibleColumns property to
return the cached list instead of recomputing it with .Where().ToList() on each
access. Ensure the cache is refreshed whenever columns are added, removed, or
their visibility changes.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Models/BitDataGridCellEventArgs.cs (1)

1-26: 🧹 Nitpick | 🔵 Trivial | 💤 Low value

Event args exposes mutable Column reference; document stability assumption.

The Column property holds a mutable reference to BitDataGridColumn<TItem>. While event args should ideally be immutable snapshots, this design is acceptable in the Blazor component context—columns are stable objects throughout the grid's lifetime. However, for future maintainers, consider adding an inline comment documenting this assumption so any refactoring (e.g., if columns become dynamically mutated) surfaces the design risk.

Alternatively, if column mutability becomes a concern, capture immutable column metadata (Id, DisplayTitle) directly into the event args instead of the Column reference itself.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Models/BitDataGridCellEventArgs.cs`
around lines 1 - 26, The `Column` property in the
`BitDataGridCellEventArgs<TItem>` class holds a mutable reference to a
`BitDataGridColumn<TItem>` object, which violates the principle that event args
should be immutable snapshots. Add an inline XML comment above the `Column`
property that documents the design assumption that column objects remain stable
throughout the grid's lifetime and warns future maintainers about the
refactoring risk if columns become dynamically mutated. Alternatively, if
mutable column objects become a concern, refactor the event args to capture only
the immutable column metadata directly (such as `Id` and `DisplayTitle`) instead
of holding a reference to the entire mutable Column object.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Infrastructure/BitDataGridDataProcessor.cs (1)

89-92: ⚠️ Potential issue | 🟠 Major | ⚡ Quick win

Use a typed, culture-invariant identity for group path keys.

Line 91 still relies on string interpolation of g.Key, which can collide when distinct keys produce identical text and causes incorrect collapse/expand state reuse.

Suggested fix

                 var keyText = column.FormatValue(g.Key);
                 var items = g.ToList();
                 // Use the raw key (not the formatted display text) for the path identifier so that
                 // distinct keys producing identical display values don't collide and share collapse/expand state.
-                var path = $"{parentPath}/{level}:{g.Key}";
+                var keyIdentity = g.Key is null
+                    ? "null"
+                    : g.Key is IFormattable f
+                        ? $"{g.Key.GetType().FullName}:{f.ToString(null, CultureInfo.InvariantCulture)}"
+                        : $"{g.Key.GetType().FullName}:{g.Key}";
+                var path = $"{parentPath}/{level}:{descriptor.ColumnId}:{keyIdentity}";

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Infrastructure/BitDataGridDataProcessor.cs`
around lines 89 - 92, In the BitDataGridDataProcessor.cs file where the path
variable is constructed using string interpolation with g.Key, replace the
simple string concatenation of g.Key with a typed, culture-invariant identifier
that prevents collisions between distinct keys producing identical text. Instead
of relying on the string representation of g.Key which can be culture-dependent
and cause identical display values to collide, use a robust uniqueness mechanism
such as the key's hash code or another unique type-safe identifier that
preserves the actual key identity across different key instances.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Models/BitDataGridAggregateResult.cs (1)

9-9: 🧹 Nitpick | 🔵 Trivial | ⚡ Quick win

Consider making FormattedValue required or nullable for consistency.

The FormattedValue property has a default value of string.Empty but is not marked as required, while ColumnId is required. This creates an inconsistent initialization pattern. If FormattedValue is always expected to have a value, mark it required; if it's truly optional, consider making it string? with a null default instead.

♻️ Proposed options

Option 1: Make it required

-    public string FormattedValue { get; init; } = string.Empty;
+    public required string FormattedValue { get; init; }

Option 2: Make it nullable

-    public string FormattedValue { get; init; } = string.Empty;
+    public string? FormattedValue { get; init; }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Models/BitDataGridAggregateResult.cs`
at line 9, The `FormattedValue` property in the `BitDataGridAggregateResult`
class has a default value of `string.Empty` but is not marked as `required`,
creating an inconsistency with the `ColumnId` property which is required. To fix
this, either mark `FormattedValue` as `required` to match the pattern of
`ColumnId`, or change its type to `string?` and set the default value to `null`
to properly represent it as an optional nullable property. Choose the approach
that best represents the semantic intent of this property in your data model.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Models/BitDataGridCellEventArgs.cs (1)

25-25: 🧹 Nitpick | 🔵 Trivial | ⚡ Quick win

Inconsistent use of required modifier.

The Value and Mouse properties are not marked as required, but based on the construction code in BitDataGrid.razor.cs:947, they are always explicitly set:

new() { Item = item, Column = column, Value = column.GetValue(item), Mouse = e }

This is inconsistent with Item and Column being marked required. Either mark Value and Mouse as required for consistency and compile-time safety, or document why they are intentionally optional.

♻️ Proposed fix for consistency

     /// <summary>The raw value of the cell.</summary>
-    public object? Value { get; init; }
+    public required object? Value { get; init; }

     /// <summary>The underlying browser mouse event.</summary>
-    public MouseEventArgs Mouse { get; init; } = new();
+    public required MouseEventArgs Mouse { get; init; }

Also applies to: 28-28

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Models/BitDataGridCellEventArgs.cs`
at line 25, The BitDataGridCellEventArgs class has inconsistent use of the
required modifier. The Value property at line 25 and Mouse property at line 28
are not marked as required, while Item and Column properties are. Since the
construction code in BitDataGrid.razor.cs always explicitly sets all four
properties when creating new instances, either add the required modifier to the
Value and Mouse properties to match Item and Column for consistency and
compile-time safety, or add documentation comments explaining why these two
properties are intentionally optional despite always being set during
construction.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

src/BlazorUI/Bit.BlazorUI.Extras/Components/QuickGrid/BitQuickGrid.razor.cs (1)

324-346: ⚠️ Potential issue | 🟠 Major | ⚡ Quick win

Ensure CTS cleanup also runs for the virtualized branch.

thisLoadCts cleanup is currently only guaranteed in the non-virtualized finally. If RefreshDataAsync() throws in the virtualized path, _pendingDataLoadCancellationTokenSource can stay non-null and undisposed.

Suggested minimal restructuring

 private async Task RefreshDataCoreAsync()
 {
     var previousCts = _pendingDataLoadCancellationTokenSource;
     if (previousCts is not null)
     {
         previousCts.Cancel();
         previousCts.Dispose();
     }
     var thisLoadCts = _pendingDataLoadCancellationTokenSource = new CancellationTokenSource();
-
-    if (_virtualizeComponent is not null)
-    {
-        await _virtualizeComponent.RefreshDataAsync();
-        if (ReferenceEquals(_pendingDataLoadCancellationTokenSource, thisLoadCts))
-        {
-            thisLoadCts.Dispose();
-            _pendingDataLoadCancellationTokenSource = null;
-        }
-    }
-    else
+    try
     {
-        _lastRefreshedPaginationStateHash = Pagination?.GetHashCode();
-        var startIndex = Pagination is null ? 0 : (Pagination.CurrentPageIndex * Pagination.ItemsPerPage);
-        var request = new BitQuickGridItemsProviderRequest<TGridItem>(
-            startIndex, Pagination?.ItemsPerPage, _sortByColumn, _sortByAscending, thisLoadCts.Token);
-        try
+        if (_virtualizeComponent is not null)
         {
-            var result = await ResolveItemsRequestAsync(request);
-            if (!thisLoadCts.IsCancellationRequested)
-            {
-                _currentNonVirtualizedViewItems = result.Items;
-                _ariaBodyRowCount = _currentNonVirtualizedViewItems.Count;
-                await (Pagination?.SetTotalItemCountAsync(result.TotalItemCount) ?? Task.CompletedTask);
-            }
+            await _virtualizeComponent.RefreshDataAsync();
         }
-        catch (OperationCanceledException)
+        else
         {
-            // This load was superseded by a newer request; swallow the cancellation and fall through
-            // to the cleanup below so the load-state remains consistent.
+            _lastRefreshedPaginationStateHash = Pagination?.GetHashCode();
+            var startIndex = Pagination is null ? 0 : (Pagination.CurrentPageIndex * Pagination.ItemsPerPage);
+            var request = new BitQuickGridItemsProviderRequest<TGridItem>(
+                startIndex, Pagination?.ItemsPerPage, _sortByColumn, _sortByAscending, thisLoadCts.Token);
+            var result = await ResolveItemsRequestAsync(request);
+            if (!thisLoadCts.IsCancellationRequested)
+            {
+                _currentNonVirtualizedViewItems = result.Items;
+                _ariaBodyRowCount = _currentNonVirtualizedViewItems.Count;
+                await (Pagination?.SetTotalItemCountAsync(result.TotalItemCount) ?? Task.CompletedTask);
+            }
         }
-        finally
-        {
-            if (ReferenceEquals(_pendingDataLoadCancellationTokenSource, thisLoadCts))
-            {
-                thisLoadCts.Dispose();
-                _pendingDataLoadCancellationTokenSource = null;
-            }
-        }
+    }
+    catch (OperationCanceledException) when (thisLoadCts.IsCancellationRequested)
+    {
+        // Superseded by a newer request.
+    }
+    finally
+    {
+        if (ReferenceEquals(_pendingDataLoadCancellationTokenSource, thisLoadCts))
+        {
+            _pendingDataLoadCancellationTokenSource = null;
+        }
+        thisLoadCts.Dispose();
     }
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/QuickGrid/BitQuickGrid.razor.cs`
around lines 324 - 346, The RefreshDataCoreAsync method's virtualized branch
does not guarantee cleanup of thisLoadCts if an exception is thrown during the
RefreshDataAsync() call on the _virtualizeComponent. The cleanup logic that
disposes thisLoadCts and clears _pendingDataLoadCancellationTokenSource (the
ReferenceEquals check) should be wrapped in a try-finally block around the
virtualized code path to ensure it always executes even when RefreshDataAsync()
throws, preventing resource leaks and keeping
_pendingDataLoadCancellationTokenSource properly managed.

src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/DataGrid/BitDataGridDemo.razor.samples.cs (1)

323-364: 🧹 Nitpick | 🔵 Trivial | ⚡ Quick win

Reset loading in finally and honor cancellation in the server-read sample.

This sample can leave loading = true if an exception/cancellation happens before Line 362. Since BitDataGridReadRequest exposes CancellationToken, it should be used in the simulated async work as well.

Suggested snippet adjustment

 private async Task<BitDataGridReadResult<Product>> LoadData(BitDataGridReadRequest request)
 {
-    loading = true;
-    await Task.Delay(250); // simulate a backend round-trip
-
-    IEnumerable<Product> query = all;
-
-    // filtering
-    foreach (var f in request.Filters)
-    {
-        var term = f.Value?.ToString() ?? "";
-        query = f.ColumnId switch
-        {
-            nameof(Product.Name) => query.Where(p => p.Name.Contains(term, StringComparison.OrdinalIgnoreCase)),
-            nameof(Product.Price) => query.Where(p => p.Price.ToString().Contains(term)),
-            nameof(Product.Id) => query.Where(p => p.Id.ToString().Contains(term)),
-            _ => query
-        };
-    }
-
-    // sorting
-    var sort = request.Sorts.FirstOrDefault();
-    if (sort is not null)
-    {
-        Func<Product, object> key = sort.ColumnId switch
-        {
-            nameof(Product.Name) => p => p.Name,
-            nameof(Product.Price) => p => p.Price,
-            _ => p => p.Id
-        };
-        query = sort.Direction == BitDataGridSortDirection.Descending
-            ? query.OrderByDescending(key)
-            : query.OrderBy(key);
-    }
-
-    // paging
-    var filtered = query.ToList();
-    var items = filtered.Skip(request.Skip).Take(request.Take ?? filtered.Count).ToList();
-
-    loading = false;
-    return new BitDataGridReadResult<Product>(items, filtered.Count);
+    loading = true;
+    try
+    {
+        await Task.Delay(250, request.CancellationToken); // simulate a backend round-trip
+
+        IEnumerable<Product> query = all;
+
+        // filtering
+        foreach (var f in request.Filters)
+        {
+            var term = f.Value?.ToString() ?? "";
+            query = f.ColumnId switch
+            {
+                nameof(Product.Name) => query.Where(p => p.Name.Contains(term, StringComparison.OrdinalIgnoreCase)),
+                nameof(Product.Price) => query.Where(p => p.Price.ToString().Contains(term)),
+                nameof(Product.Id) => query.Where(p => p.Id.ToString().Contains(term)),
+                _ => query
+            };
+        }
+
+        // sorting
+        var sort = request.Sorts.FirstOrDefault();
+        if (sort is not null)
+        {
+            Func<Product, object> key = sort.ColumnId switch
+            {
+                nameof(Product.Name) => p => p.Name,
+                nameof(Product.Price) => p => p.Price,
+                _ => p => p.Id
+            };
+            query = sort.Direction == BitDataGridSortDirection.Descending
+                ? query.OrderByDescending(key)
+                : query.OrderBy(key);
+        }
+
+        // paging
+        var filtered = query.ToList();
+        var items = filtered.Skip(request.Skip).Take(request.Take ?? filtered.Count).ToList();
+        return new BitDataGridReadResult<Product>(items, filtered.Count);
+    }
+    finally
+    {
+        loading = false;
+    }
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/DataGrid/BitDataGridDemo.razor.samples.cs`
around lines 323 - 364, The LoadData method sets loading to true but only resets
it to false at the end of the method, leaving it stuck at true if an exception
occurs. Additionally, the simulated async work via Task.Delay does not honor the
CancellationToken from the BitDataGridReadRequest. Wrap the method body in a
try-finally block and move the loading = false assignment to the finally block
to ensure it always executes regardless of exceptions. Also, pass
request.CancellationToken to the Task.Delay call to respect cancellation
requests.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor (2)

403-403: 🧹 Nitpick | 🔵 Trivial | 💤 Low value

int.Parse could throw on malformed select value.

While the <select> only contains valid integer options, using int.Parse without validation is fragile. Consider int.TryParse for defensive coding.

♻️ Defensive parsing

-<select class="bit-dtg-page-size" `@onchange`="e => SetPageSizeAsync(int.Parse((string)e.Value!))">
+<select class="bit-dtg-page-size" `@onchange`="e => { if (int.TryParse((string?)e.Value, out var size)) _ = SetPageSizeAsync(size); }">

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor` at
line 403, The select element's `@onchange` handler in the page size dropdown uses
int.Parse without error handling, which can throw exceptions if the value is
malformed. Replace int.Parse((string)e.Value!) with int.TryParse to safely
attempt the conversion and gracefully handle parsing failures. Check the result
of TryParse before calling SetPageSizeAsync, and only proceed if the conversion
succeeds.

---

27-31: 🧹 Nitpick | 🔵 Trivial | ⚖️ Poor tradeoff

CSV data URI export may fail for large datasets.

The CSV export uses a data:text/csv URI which has browser-specific length limits (typically 2MB in modern browsers, but varies). For grids with thousands of rows, this approach may silently truncate or fail.

Consider adding a fallback using Blob URLs or JS interop for larger exports if this becomes an issue.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor`
around lines 27 - 31, The CSV export functionality in the BitDataGrid component
uses a data:text/csv URI approach which has browser limitations (typically 2MB)
and may silently fail for large datasets. Modify the CSV export section to check
the size of the CSV data generated by the ToCsv() method, and if it exceeds a
reasonable threshold (around 1-2MB), implement a fallback approach using Blob
URLs or JavaScript interop to trigger the download instead of using the data
URI. This ensures large exports work reliably while maintaining backward
compatibility for smaller datasets that work fine with the current data URI
approach.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor.cs (3)

226-226: 🧹 Nitpick | 🔵 Trivial | ⚡ Quick win

VisibleColumns allocates a new list on every access.

The property VisibleColumns calls .ToList() on every access, creating a new allocation each time. It's accessed frequently (header rendering, cell navigation, spanning, footer, etc.), causing unnecessary GC pressure.

♻️ Consider caching the visible columns list

+    private IReadOnlyList<BitDataGridColumn<TItem>>? _visibleColumnsCache;
+    private int _visibleColumnsVersion;
+
-    internal IReadOnlyList<BitDataGridColumn<TItem>> VisibleColumns => _columns.Where(c => c.Visible).ToList();
+    internal IReadOnlyList<BitDataGridColumn<TItem>> VisibleColumns
+    {
+        get
+        {
+            // Invalidate cache when columns change
+            if (_visibleColumnsCache is null || _visibleColumnsVersion != _columns.Count)
+            {
+                _visibleColumnsCache = _columns.Where(c => c.Visible).ToList();
+                _visibleColumnsVersion = _columns.Count;
+            }
+            return _visibleColumnsCache;
+        }
+    }

Also invalidate the cache in AddColumn, RemoveColumn, and SetColumnVisibilityAsync.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor.cs` at
line 226, The VisibleColumns property creates a new list allocation on every
access via .ToList(), causing unnecessary garbage collection. Cache the filtered
list result in a private field (e.g., _visibleColumnsCache) and update the
VisibleColumns property to return the cached value. Invalidate the cache by
resetting it to null in the AddColumn, RemoveColumn, and
SetColumnVisibilityAsync methods so the list is only recalculated when columns
are actually modified, not on every property access.

---

734-735: 🧹 Nitpick | 🔵 Trivial | 💤 Low value

Multiple enumerations over _pageItems for selection state.

AllPageSelected and SomePageSelected both call _pageItems.Where(CanSelectRow) multiple times, causing repeated enumeration. Consider caching the selectable items.

♻️ Suggested optimization

-    internal bool AllPageSelected => _pageItems.Where(CanSelectRow).Any() && _pageItems.Where(CanSelectRow).All(_selected.Contains);
-    internal bool SomePageSelected => _pageItems.Where(CanSelectRow).Any(_selected.Contains) && !AllPageSelected;
+    internal bool AllPageSelected
+    {
+        get
+        {
+            var selectable = _pageItems.Where(CanSelectRow).ToList();
+            return selectable.Count > 0 && selectable.All(_selected.Contains);
+        }
+    }
+
+    internal bool SomePageSelected
+    {
+        get
+        {
+            var selectable = _pageItems.Where(CanSelectRow).ToList();
+            return selectable.Any(_selected.Contains) && !selectable.All(_selected.Contains);
+        }
+    }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor.cs`
around lines 734 - 735, The AllPageSelected and SomePageSelected properties both
enumerate _pageItems.Where(CanSelectRow) multiple times within their respective
expressions, causing inefficient repeated filtering. Refactor both properties by
caching the filtered enumerable result (the result of
_pageItems.Where(CanSelectRow)) into a local variable first, then use that
cached variable in the subsequent checks with Any, All, and Contains operations
to avoid multiple enumerations.

---

1068-1072: 🧹 Nitpick | 🔵 Trivial | ⚡ Quick win

Unnecessary list allocation in ResolveColSpan.

cols.ToList().IndexOf(column) creates a temporary list just to find the index. Use a loop or LINQ instead.

♻️ Suggested fix

     internal int ResolveColSpan(BitDataGridColumn<TItem> column, TItem item)
     {
         if (column.ColSpan is null) return 1;
         var span = column.ColSpan(item) ?? 1;
         if (span < 1) span = 1;
         var cols = VisibleColumns;
-        var idx = cols.ToList().IndexOf(column);
+        var idx = -1;
+        for (int i = 0; i < cols.Count; i++)
+        {
+            if (cols[i] == column) { idx = i; break; }
+        }
         if (idx < 0) return 1;
         return Math.Min(span, cols.Count - idx);
     }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor.cs`
around lines 1068 - 1072, The ResolveColSpan method is creating an unnecessary
temporary list by calling cols.ToList() solely to use the IndexOf method for
finding the column's position. Replace this inefficient approach by either using
LINQ enumeration-based indexing without materialization, or iterating through
the cols collection with a counter to find the index position directly, avoiding
the allocation of the temporary list.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGridCellEditor.razor (1)

24-31: 🧹 Nitpick | 🔵 Trivial | 💤 Low value

Select element has redundant value binding.

The <select> element has both value="@(GetString())" and each <option> has selected="@(name == GetString())". The Blazor value binding on <select> should suffice; the explicit selected attribute is redundant and can cause inconsistent behavior in some browsers.

♻️ Suggested simplification

-        <select class="bit-dtg-editor" value="@(GetString())" `@onchange`="e => Set(e.Value)">
+        <select class="bit-dtg-editor" `@bind`="`@_enumValue`" `@bind`:event="onchange" `@bind`:after="() => Set(_enumValue)">
             `@foreach` (var name in Enum.GetNames(Column.Accessor!.UnderlyingType))
             {
-                <option value="`@name`" selected="@(name == GetString())">`@name`</option>
+                <option value="`@name`">`@name`</option>
             }
         </select>

Or simply remove the selected attribute since value on <select> handles selection:

-                <option value="`@name`" selected="@(name == GetString())">`@name`</option>
+                <option value="`@name`">`@name`</option>

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGridCellEditor.razor`
around lines 24 - 31, The Enum case in the BitDataGridCellEditor.razor component
has redundant selection binding on the select element. Remove the explicit
selected="@(name == GetString())" attribute from each option element within the
foreach loop, as the value binding on the parent select element with
value="@(GetString())" already handles selecting the correct option in Blazor.
Keep only the value binding on the select element for proper Blazor two-way
binding behavior.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/DataGrid/SampleData.cs (1)

13-68: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Consider extracting common generation logic to reduce duplication.

The Generate and GeneratePersian methods duplicate the entire Product generation algorithm. Only the string arrays differ (adjectives, nouns, suppliers). Extracting the common logic into a shared helper would improve maintainability and ensure consistency when updating the generation algorithm.

♻️ Refactoring approach

Extract a private helper that accepts the string arrays as parameters:

+    private static List<Product> GenerateCore(
+        int count,
+        int seed,
+        string[] adjectives,
+        string[] nouns,
+        string[] suppliers)
+    {
+        var rng = new Random(seed);
+        var categories = Enum.GetValues<Category>();
+        var list = new List<Product>(count);
+        var referenceDate = new DateTime(2024, 1, 1);
+        for (int i = 1; i <= count; i++)
+        {
+            list.Add(new Product
+            {
+                Id = i,
+                Name = $"{adjectives[rng.Next(adjectives.Length)]} {nouns[rng.Next(nouns.Length)]} {rng.Next(100, 999)}",
+                Category = categories[rng.Next(categories.Length)],
+                Price = Math.Round((decimal)(rng.NextDouble() * 990 + 5), 2),
+                Stock = rng.Next(0, 500),
+                Rating = Math.Round(rng.NextDouble() * 4 + 1, 1),
+                Discontinued = rng.Next(0, 5) == 0,
+                ReleaseDate = referenceDate.AddDays(-rng.Next(0, 2000)),
+                Supplier = suppliers[rng.Next(suppliers.Length)]
+            });
+        }
+        return list;
+    }
+
     public static List<Product> Generate(int count, int seed = 42)
-    {
-        var rng = new Random(seed);
-        var categories = Enum.GetValues<Category>();
-        var list = new List<Product>(count);
-        var referenceDate = new DateTime(2024, 1, 1);
-        for (int i = 1; i <= count; i++)
-        {
-            list.Add(new Product
-            {
-                Id = i,
-                Name = $"{Adjectives[rng.Next(Adjectives.Length)]} {Nouns[rng.Next(Nouns.Length)]} {rng.Next(100, 999)}",
-                Category = categories[rng.Next(categories.Length)],
-                Price = Math.Round((decimal)(rng.NextDouble() * 990 + 5), 2),
-                Stock = rng.Next(0, 500),
-                Rating = Math.Round(rng.NextDouble() * 4 + 1, 1),
-                Discontinued = rng.Next(0, 5) == 0,
-                ReleaseDate = referenceDate.AddDays(-rng.Next(0, 2000)),
-                Supplier = Suppliers[rng.Next(Suppliers.Length)]
-            });
-        }
-        return list;
-    }
+        => GenerateCore(count, seed, Adjectives, Nouns, Suppliers);

     public static List<Product> GeneratePersian(int count, int seed = 42)
-    {
-        var rng = new Random(seed);
-        var categories = Enum.GetValues<Category>();
-        var list = new List<Product>(count);
-        var referenceDate = new DateTime(2024, 1, 1);
-        for (int i = 1; i <= count; i++)
-        {
-            list.Add(new Product
-            {
-                Id = i,
-                Name = $"{PersianAdjectives[rng.Next(PersianAdjectives.Length)]} {PersianNouns[rng.Next(PersianNouns.Length)]} {rng.Next(100, 999)}",
-                Category = categories[rng.Next(categories.Length)],
-                Price = Math.Round((decimal)(rng.NextDouble() * 990 + 5), 2),
-                Stock = rng.Next(0, 500),
-                Rating = Math.Round(rng.NextDouble() * 4 + 1, 1),
-                Discontinued = rng.Next(0, 5) == 0,
-                ReleaseDate = referenceDate.AddDays(-rng.Next(0, 2000)),
-                Supplier = PersianSuppliers[rng.Next(PersianSuppliers.Length)]
-            });
-        }
-        return list;
-    }
+        => GenerateCore(count, seed, PersianAdjectives, PersianNouns, PersianSuppliers);

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/DataGrid/SampleData.cs`
around lines 13 - 68, The Generate and GeneratePersian methods contain duplicate
code for the entire Product generation algorithm, differing only in which string
arrays they use. Create a private helper method that accepts three string array
parameters (for adjectives, nouns, and suppliers) and contains the common
generation logic currently duplicated in both methods. Then refactor the
Generate method to call this helper with Adjectives, Nouns, and Suppliers
arrays, and the GeneratePersian method to call it with PersianAdjectives,
PersianNouns, and PersianSuppliers arrays. This will eliminate duplication while
maintaining the same external behavior.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/DataGrid/BitDataGridDemo.razor.cs (1)

141-147: 🩺 Stability & Availability | 🟠 Major

Move the cancellable delay inside try so cleanup always remains in scope.

At Line 143, await Task.Delay(250, request.CancellationToken) can throw before the try block at Line 146, causing the finally cleanup (Lines 198–209) to be bypassed and leaving serverLoading in an inconsistent state.

Proposed fix

 private async Task<BitDataGridReadResult<Product>> LoadServerData(BitDataGridReadRequest request)
 {
     serverLoading = true;
     await InvokeAsync(StateHasChanged);
-    await Task.Delay(250, request.CancellationToken);

     int total = 0;
     try
     {
+        await Task.Delay(250, request.CancellationToken);
+
         IEnumerable<Product> query = serverAll;

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/DataGrid/BitDataGridDemo.razor.cs`
around lines 141 - 147, The cancellable Task.Delay on line 143 can throw a
cancellation exception before entering the try block that starts on line 146,
which causes the finally cleanup block to be bypassed and leaves serverLoading
in an inconsistent state. Move the await Task.Delay(250,
request.CancellationToken) statement inside the try block so that the finally
cleanup block (lines 198-209) will always execute regardless of whether the
delay is cancelled, ensuring serverLoading is properly reset.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor.cs (1)

1226-1235: 🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

Quote CSV fields containing carriage returns.

Line 1233 quotes \n but not \r, so CR-only values can split rows in spreadsheet parsers. Include \r in the quoting condition.

Suggested fix

-            return v.Contains(',') || v.Contains('"') || v.Contains('\n')
+            return v.Contains(',') || v.Contains('"') || v.Contains('\n') || v.Contains('\r')
                 ? "\"" + v.Replace("\"", "\"\"") + "\""
                 : v;

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor.cs`
around lines 1226 - 1235, The Escape method checks for newline characters (\n)
when deciding whether to quote CSV fields, but it does not include carriage
return characters (\r) in the quoting condition. Update the return statement in
the Escape method to also check for \r using an additional .Contains('\r')
condition alongside the existing checks for comma, double quote, and newline, so
that fields containing carriage returns are properly quoted to prevent row
splitting in spreadsheet parsers.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Models/BitDataGridFilterDescriptor.cs (1)

4-9: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Add XML documentation to properties.

All properties lack documentation summaries, reducing IntelliSense discoverability.

📝 Proposed XML documentation additions

 public sealed class BitDataGridFilterDescriptor
 {
+    /// <summary>Identifier of the column being filtered.</summary>
     public required string ColumnId { get; init; }
+    /// <summary>The filter operation to apply (e.g., Contains, Equals, GreaterThan).</summary>
     public BitDataGridFilterOperator Operator { get; set; } = BitDataGridFilterOperator.Contains;
+    /// <summary>The filter value to compare against, or null for operators like IsNull.</summary>
     public object? Value { get; set; }
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Models/BitDataGridFilterDescriptor.cs`
around lines 4 - 9, The BitDataGridFilterDescriptor class properties (ColumnId,
Operator, and Value) lack XML documentation comments, which prevents
IntelliSense from displaying helpful information for developers using these
properties. Add XML documentation summary comments above each property using the
standard /// <summary> syntax to describe what each property represents and its
purpose in the filter descriptor context.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Models/BitDataGridAggregateResult.cs (1)

4-10: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Add XML documentation to properties for IntelliSense clarity.

All properties lack individual doc summaries. Even simple DTOs benefit from documentation that appears in IDE tooltips and API docs.

📝 Proposed XML documentation additions

 public sealed class BitDataGridAggregateResult
 {
+    /// <summary>Identifier of the column this aggregate result applies to.</summary>
     public required string ColumnId { get; init; }
+    /// <summary>The type of aggregate function applied (sum, average, count, etc.).</summary>
     public BitDataGridAggregateType Type { get; init; }
+    /// <summary>The raw computed aggregate value, or null if computation produced no result.</summary>
     public object? Value { get; init; }
+    /// <summary>The formatted string representation of the aggregate value for display.</summary>
     public required string FormattedValue { get; init; }
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Models/BitDataGridAggregateResult.cs`
around lines 4 - 10, The BitDataGridAggregateResult class and its properties are
missing XML documentation comments that would provide IntelliSense clarity in
IDEs and API documentation. Add XML documentation comments above each property
(ColumnId, Type, Value, and FormattedValue) in the BitDataGridAggregateResult
class using the summary tags to describe what each property represents, its
purpose, and any relevant details about its usage or constraints.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Infrastructure/BitDataGridGroup.cs (1)

10-26: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Add XML documentation to undocumented properties for better IntelliSense discoverability.

Properties ColumnId, KeyText, Aggregates, and the computed property HasSubGroups lack XML documentation summaries, which reduces discoverability in IntelliSense and impacts documentation generation. Lines 14 and 30 demonstrate the pattern already in use.

📝 Proposed XML documentation additions

     public sealed class BitDataGridGroup<TItem>
     {
+        /// <summary>Identifier of the column used for grouping.</summary>
         public required string ColumnId { get; init; }
+        /// <summary>The grouping key value for this group.</summary>
         public required object? Key { get; init; }
+        /// <summary>Human-readable text representation of the grouping key.</summary>
         public string KeyText { get; init; } = string.Empty;
 
         /// <summary>Zero-based nesting depth (0 = top level).</summary>
         public int Level { get; init; }
 
         /// <summary>Stable, unique path identifying this group across the whole tree (used for collapse state).</summary>
         public required string Path { get; init; }
 
         /// <summary>All rows that fall under this group (across nested subgroups).</summary>
         public List<TItem> Items { get; init; } = new();
 
         /// <summary>Child groups when this group is further grouped; empty for leaf groups.</summary>
         public List<BitDataGridGroup<TItem>> SubGroups { get; init; } = new();
 
+        /// <summary>Computed aggregates (e.g., sum, average) for columns in this group.</summary>
         public List<BitDataGridAggregateResult> Aggregates { get; init; } = new();
 
+        /// <summary>Indicates whether this group contains child groups (subgroups).</summary>
         public bool HasSubGroups => SubGroups.Count > 0;

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Infrastructure/BitDataGridGroup.cs`
around lines 10 - 26, The properties ColumnId, KeyText, and Aggregates in the
BitDataGridGroup class are missing XML documentation summaries, which reduces
IntelliSense discoverability. Add XML documentation comments above each of these
properties following the same pattern already used for Level, Path, Items, and
SubGroups properties. Each summary should provide a brief description of what
the property represents in the context of data grid grouping.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

src/BlazorUI/Bit.BlazorUI.Extras/Components/QuickGrid/BitQuickGrid.razor.cs (1)

305-317: 🎯 Functional Correctness | 🟠 Major | ⚡ Quick win

Rebind when ResizableColumns flips, not just when the column hash changes.

Line 312 only looks at _columns, so false -> true (or true -> false -> true) with the same columns never calls BitQuickGridInit(...). The new .bit-qkg-drg handles render, but resizing stays inert.

Suggested fix

+    private bool _lastRenderHadResizableColumns;
+
     protected override async Task OnAfterRenderAsync(bool firstRender)
     {
         if (firstRender)
         {
             _jsEventDisposable = await _js.BitQuickGridInit(_tableReference);
             _lastInitColumnsHash = ComputeColumnsHash();
+            _lastRenderHadResizableColumns = ResizableColumns;
         }
-        else if (ResizableColumns)
+        else
         {
-            var hash = ComputeColumnsHash();
-            if (hash != _lastInitColumnsHash)
+            var hash = ComputeColumnsHash();
+            var shouldRebind = ResizableColumns
+                && (hash != _lastInitColumnsHash || _lastRenderHadResizableColumns is false);
+
+            _lastInitColumnsHash = hash;
+            _lastRenderHadResizableColumns = ResizableColumns;
+
+            if (shouldRebind)
             {
-                _lastInitColumnsHash = hash;
                 await StopJsEventsAsync();
                 _jsEventDisposable = await _js.BitQuickGridInit(_tableReference);
             }
         }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/QuickGrid/BitQuickGrid.razor.cs`
around lines 305 - 317, The resize initialization in BitQuickGrid.razor.cs only
re-runs when ComputeColumnsHash() changes, so toggling ResizableColumns on and
off with the same columns leaves the new .bit-qkg-drg handles unbound. Update
the logic around the _lastInitColumnsHash / _jsEventDisposable flow in the
render path so BitQuickGridInit(...) also runs when ResizableColumns changes
state, not just when the column hash differs, and make sure the previous JS
registration is stopped before rebinding.

src/BlazorUI/Bit.BlazorUI.Extras/Styles/extra-components.scss (1)

4-5: 📐 Maintainability & Code Quality | 🟠 Major | ⚡ Quick win

Remove .scss extensions from @import paths.

The .scss extensions violate the scss/load-partial-extension stylelint rule and will fail CI linting.

-@import "../Components/QuickGrid/BitQuickGrid.scss";
-@import "../Components/QuickGrid/Pagination/BitQuickGridPaginator.scss";
+@import "../Components/QuickGrid/BitQuickGrid";
+@import "../Components/QuickGrid/Pagination/BitQuickGridPaginator";

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Styles/extra-components.scss` around lines 4
- 5, The `@import` statements in extra-components.scss use explicit .scss
extensions, which violates the scss/load-partial-extension rule. Update the
imports to reference the partials without the extension, using the existing
BitQuickGrid and BitQuickGridPaginator paths so the stylesheet continues to
resolve correctly and passes linting.

src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/QuickGrid/BitQuickGridDemo.razor (1)

4-4: ⚠️ Potential issue | 🔴 Critical

Fix the DTO namespace import.

Line 4 still imports Demo.Shared.Dtos.QuickGridDemo, while the moved DTOs and this page's code-behind use Bit.BlazorUI.Demo.Shared.Dtos.QuickGridDemo. This Razor file will not resolve the QuickGrid demo DTOs until the import matches.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/QuickGrid/BitQuickGridDemo.razor`
at line 4, The QuickGrid demo Razor page still imports the old DTO namespace, so
update the `@using` in BitQuickGridDemo.razor to match the moved DTOs used by the
code-behind: Bit.BlazorUI.Demo.Shared.Dtos.QuickGridDemo instead of
Demo.Shared.Dtos.QuickGridDemo. Make the namespace import consistent with the
demo DTO types so the page can resolve the QuickGrid demo models correctly.